home *** CD-ROM | disk | FTP | other *** search
/ Experimental BBS Explossion 3 / Experimental BBS Explossion III.iso / os2 / pmfract2.zip / FRACTINT.FRM < prev    next >
Text File  |  1991-10-13  |  16KB  |  673 lines
  1. comment {
  2.  FRACTINT.DOC has instructions for adding new formulas to this file.
  3.  There are several hard-coded restrictions in the formula interpreter:
  4.  
  5.  1) The fractal name through the open curly bracket must be on a single line.
  6.  2) There is a hard-coded limit of 200 formulas per formula file, only
  7.     because of restrictions in the prompting routines.
  8.  3) Formulas can containt at most 250 operations (references to variables and
  9.     arithmetic); this is bigger than it sounds, no formula in the default
  10.     fractint.frm uses even 100
  11.  3) Comment blocks can be set up using dummy formulas with no formula name
  12.     or with the special name "comment".
  13.  
  14.  The formulas at the beginning of this file are from Mark Peterson, who
  15.  built this fractal interpreter feature.  The rest are grouped by contributor.
  16.  (Scott Taylor sent many but they are no longer here - they've been
  17.  incorporated as hard-coded types.  Lee Skinner also sent many which have
  18.  now been hard-coded.)
  19.  
  20.  Note that the builtin "cos" function had a bug which was corrected in
  21.  version 16.  To recreate an image from a formula which used cos before
  22.  v16, change "cos" in the formula to "cosxx" which is a new function
  23.  provided for backward compatibility with that bug.
  24.  }
  25.  
  26. Mandelbrot(XAXIS) {; Mark Peterson
  27.   ; Classical fractal showing LastSqr speedup
  28.   z = Pixel, z = Sqr(z):  ; Start with z**2 to initialize LastSqr
  29.    z = z + Pixel
  30.    z = Sqr(z)
  31.     LastSqr <= 4      ; Use LastSqr instead of recalculating
  32.   }
  33.  
  34. Dragon (ORIGIN) {; Mark Peterson
  35.   z = Pixel:
  36.    z = sqr(z) + (-0.74543, 0.2),
  37.     |z| <= 4
  38.   }
  39.  
  40. Daisy (ORIGIN) {; Mark Peterson
  41.   z = pixel:
  42.    z = z*z + (0.11031, -0.67037),
  43.     |z| <= 4
  44.   }
  45.  
  46. InvMandel (XAXIS) {; Mark Peterson
  47.   c = z = 1 / pixel:
  48.    z = sqr(z) + c;
  49.     |z| <= 4
  50.   }
  51.  
  52. DeltaLog(XAXIS) {; Mark Peterson
  53.   z = pixel, c = log(pixel):
  54.    z = sqr(z) + c,
  55.     |z| <= 4
  56.   }
  57.  
  58. Newton4(XYAXIS) {; Mark Peterson
  59.   z = pixel, Root = 1:
  60.    z3 = z*z*z;
  61.    z4 = z3 * z;
  62.    z = (3 * z4 + Root) / (4 * z3);
  63.     .004 <= |z4 - Root|
  64.   }
  65.  
  66. comment {
  67.    The following are from Chris Green:
  68.    These fractals all use Newton's or Halley's formula for approximation
  69.    of a function.  In all of these fractals, p1 is the "relaxation
  70.    coefficient". A value of 1 gives the conventional newton or halley
  71.    iteration. Values <1 will generally produce less chaos than values >1.
  72.    1-1.5 is probably a good range to try.  P2 is the imaginary component
  73.    of the relaxation coefficient, and should be zero but maybe a small
  74.    non-zero value will produce something interesting. Who knows?
  75.    For more information on Halley maps, see "Computers, Pattern, Chaos,
  76.    and Beauty" by Pickover.
  77.    }
  78.  
  79. Halley (XYAXIS) {; Chris Green. Halley's formula applied to x^7-x=0.
  80.   ; P1 usually 1 to 1.5, P2 usually zero. Use floating point.
  81.   ; Setting P1 to 1 creates the picture on page 277 of Pickover's book
  82.   z=pixel:
  83.    z5=z*z*z*z*z;
  84.    z6=z*z5;
  85.    z7=z*z6;
  86.    z=z-p1*((z7-z)/ ((7.0*z6-1)-(42.0*z5)*(z7-z)/(14.0*z6-2))),
  87.     0.0001 <= |z7-z|
  88.   }
  89.  
  90. CGhalley (XYAXIS) {; Chris Green -- Halley's formula
  91.   ; P1 usually 1 to 1.5, P2 usually zero. Use floating point.
  92.   z=(1,1):
  93.    z5=z*z*z*z*z;
  94.    z6=z*z5;
  95.    z7=z*z6;
  96.    z=z-p1*((z7-z-pixel)/ ((7.0*z6-1)-(42.0*z5)*(z7-z-pixel)/(14.0*z6-2))),
  97.     0.0001 <= |z7-z-pixel|
  98.   }
  99.  
  100. halleySin (XYAXIS) {; Chris Green. Halley's formula applied to sin(x)=0.
  101.   ; Use floating point.
  102.   ; P1 = 0.1 will create the picture from page 281 of Pickover's book.
  103.   z=pixel:
  104.    s=sin(z), c=cos(z)
  105.    z=z-p1*(s/(c-(s*s)/(c+c))),
  106.     0.0001 <= |s|
  107.   }
  108.  
  109. NewtonSinExp (XAXIS) {; Chris Green
  110.   ; Newton's formula applied to sin(x)+exp(x)-1=0.
  111.   ; Use floating point.
  112.   z=pixel:
  113.    z1=exp(z)
  114.    z2=sin(z)+z1-1
  115.    z=z-p1*z2/(cos(z)+z1),
  116.     .0001 < |z2|
  117.   }
  118.  
  119. CGNewton3 {; Chris Green -- A variation on newton iteration.
  120.   ; The initial guess is fixed at (1,1), but the equation solved
  121.   ; is different at each pixel ( x^3-pixel=0 is solved).
  122.   ; Use floating point.
  123.   ; Try P1=1.8.
  124.   z=(1,1):
  125.    z2=z*z;
  126.    z3=z*z2;
  127.    z=z-p1*(z3-pixel)/(3.0*z2),
  128.     0.0001 < |z3-pixel|
  129.   }
  130.  
  131. HyperMandel {; Chris Green.
  132.   ; A four dimensional version of the mandelbrot set.
  133.   ; Use P1 to select which two-dimensional plane of the
  134.   ; four dimensional set you wish to examine.
  135.   ; Use floating point.
  136.   a=(0,0),b=(0,0):
  137.    z=z+1
  138.    anew=sqr(a)-sqr(b)+pixel
  139.    b=2.0*a*b+p1
  140.    a=anew,
  141.     |a|+|b| <= 4
  142.   }
  143.  
  144.  
  145. MTet (XAXIS) {; Mandelbrot form 1 of the Tetration formula --Lee Skinner
  146.   z = pixel:
  147.    z = (pixel ^ z) + pixel,
  148.     |z| <= (P1 + 3)
  149.   }
  150.  
  151. AltMTet(XAXIS) {; Mandelbrot form 2 of the Tetration formula --Lee Skinner
  152.   z = 0:
  153.    z = (pixel ^ z) + pixel,
  154.     |z| <= (P1 + 3)
  155.   }
  156.  
  157. JTet (XAXIS) {; Julia form 1 of the Tetration formula --Lee Skinner
  158.   z = pixel:
  159.    z = (pixel ^ z) + P1,
  160.     |z| <= (P2 + 3)
  161.   }
  162.  
  163. AltJTet (XAXIS) {; Julia form 2 of the Tetration formula --Lee Skinner
  164.   z = P1:
  165.    z = (pixel ^ z) + P1,
  166.     |z| <= (P2 + 3)
  167.   }
  168.  
  169. Cubic (XYAXIS) {; Lee Skinner
  170.   p = pixel, test = p1 + 3,
  171.   t3 = 3*p, t2 = p*p,
  172.   a = (t2 + 1)/t3, b = 2*a*a*a + (t2 - 2)/t3,
  173.   aa3 = a*a*3, z = 0 - a :
  174.    z = z*z*z - aa3*z + b,
  175.     |z| < test
  176.  }
  177.  
  178. { The following are from Lee Skinner, have been partially generalized. }
  179.  
  180. Fzppfnre  {; Lee Skinner
  181.   z = pixel, f = 1./(pixel):
  182.    z = fn1(z) + f,
  183.     |z| <= 50
  184.   }
  185.  
  186. Fzppfnpo  {; Lee Skinner
  187.   z = pixel, f = (pixel)^(pixel):
  188.    z = fn1(z) + f,
  189.     |z| <= 50
  190.   }
  191.  
  192. Fzppfnsr  {; Lee Skinner
  193.   z = pixel, f = (pixel)^.5:
  194.    z = fn1(z) + f,
  195.     |z| <= 50
  196.   }
  197.  
  198. Fzppfnta  {; Lee Skinner
  199.   z = pixel, f = tan(pixel):
  200.    z = fn1(z) + f,
  201.     |z|<= 50
  202.   }
  203.  
  204. Fzppfnct  {; Lee Skinner
  205.   z = pixel, f = cos(pixel)/sin(pixel):
  206.    z = fn1(z) + f,
  207.     |z|<= 50
  208.   }
  209.  
  210. Fzppfnse  {; Lee Skinner
  211.   z = pixel, f = 1./sin(pixel):
  212.    z = fn1(z) + f,
  213.     |z| <= 50
  214.   }
  215.  
  216. Fzppfncs  {; Lee Skinner
  217.   z = pixel, f = 1./cos(pixel):
  218.    z = fn1(z) + f,
  219.     |z| <= 50
  220.   }
  221.  
  222. Fzppfnth  {; Lee Skinner
  223.   z = pixel, f = tanh(pixel):
  224.    z = fn1(z)+f,
  225.     |z|<= 50
  226.   }
  227.  
  228. Fzppfnht  {; Lee Skinner
  229.   z = pixel, f = cosh(pixel)/sinh(pixel):
  230.    z = fn1(z)+f,
  231.     |z|<= 50
  232.   }
  233.  
  234. Fzpfnseh  {; Lee Skinner
  235.   z = pixel, f = 1./sinh(pixel):
  236.    z = fn1(z) + f,
  237.     |z| <= 50
  238.   }
  239.  
  240. Fzpfncoh  {; Lee Skinner
  241.   z = pixel, f = 1./cosh(pixel):
  242.    z = fn1(z) + f,
  243.     |z| <= 50
  244.   }
  245.  
  246.  
  247. { The following resulted from a FRACTINT bug. Version 13 incorrectly
  248.   calculated Spider (see above). We fixed the bug, and reverse-engineered
  249.   what it was doing to Spider - so here is the old "spider" }
  250.  
  251. Wineglass(XAXIS) {; Pieter Branderhorst
  252.   c = z = pixel:
  253.    z = z * z + c
  254.    c = (1+flip(imag(c))) * real(c) / 2 + z,
  255.     |z| <= 4 }
  256.  
  257.  
  258. { The following is from Scott Taylor.
  259.   Scott says they're "Dog" because the first one he looked at reminded him
  260.   of a hot dog. This was originally several fractals, we have generalized it. }
  261.  
  262. FnDog(XYAXIS)  {; Scott Taylor
  263.   z = Pixel, b = p1+2:
  264.    z = fn1( z ) * pixel,
  265.     |z| <= b
  266.   }
  267.  
  268. Ent {; Scott Taylor
  269.   ; Try params=.5/.75 and the first function as exp.
  270.   ; Zoom in on the swirls around the middle.  There's a
  271.   ; symmetrical area surrounded by an asymmetric area.
  272.   z = Pixel, y = fn1(z), base = log(p1):
  273.    z = y * log(z)/base,
  274.     |z| <= 4
  275.   }
  276.  
  277. Ent2 {; Scott Taylor
  278.   ; try params=2/1, functions=cos/cosh, potential=255/355
  279.   z = Pixel, y = fn1(z), base = log(p1):
  280.    z = fn2( y * log(z) / base ),
  281.     |z| <= 4
  282.   }
  283.  
  284. { From Kevin Lee: }
  285.  
  286. LeeMandel1(XYAXIS) {; Kevin Lee
  287.   z=Pixel:
  288. ;; c=sqr(pixel)/z, c=z+c, z=sqr(z),  this line was an error in v16
  289.    c=sqr(pixel)/z, c=z+c, z=sqr(c),
  290.     |z|<4
  291.   }
  292.  
  293. LeeMandel2(XYAXIS) {; Kevin Lee
  294.   z=Pixel:
  295.    c=sqr(pixel)/z, c=z+c, z=sqr(c*pixel),
  296.     |z|<4
  297.    }
  298.  
  299. LeeMandel3(XAXIS) {; Kevin Lee
  300.   z=Pixel, c=Pixel-sqr(z):
  301.    c=Pixel+c/z, z=c-z*pixel,
  302.     |z|<4
  303.   }
  304.  
  305. { These are a few of the examples from the book,
  306.   Fractal Creations, by Tim Wegner and Mark Peterson. }
  307.  
  308. MyFractal {; Fractal Creations example
  309.   c = z = 1/pixel:
  310.    z = sqr(z) + c;
  311.     |z| <= 4
  312.   }
  313.  
  314. Bogus1 {; Fractal Creations example
  315.   z = 0; z = z + * 2,
  316.    |z| <= 4 }
  317.  
  318. MandelTangent {; Fractal Creations example (revised for v.16)
  319.   z = pixel:
  320.    z = pixel * tan(z),
  321.     |real(z)| < 32
  322.   }
  323.  
  324. Mandel3 {; Fractal Creations example
  325.   z = pixel, c = sin(z):
  326.    z = (z*z) + c;
  327.    z = z * 1/c;
  328.     |z| <= 4;
  329.    }
  330.  
  331. { These are from: "AKA MrWizard W. LeRoy Davis;SM-ALC/HRUC"
  332.           davisl@sm-logdis1-aflc.af.mil
  333.   The first 3 are variations of:
  334.                z
  335.        gamma(z) = (z/e) * sqrt(2*pi*z) * R        }
  336.  
  337. Sterling(XAXIS) {; davisl
  338.   z = Pixel:
  339.    z = ((z/2.7182818)^z)/sqr(6.2831853*z),
  340.     |z| <= 4
  341.   }
  342.  
  343. Sterling2(XAXIS) {; davisl
  344.   z = Pixel:
  345.    z = ((z/2.7182818)^z)/sqr(6.2831853*z) + pixel,
  346.     |z| <= 4
  347.   }
  348.  
  349. Sterling3(XAXIS) {; davisl
  350.   z = Pixel:
  351.    z = ((z/2.7182818)^z)/sqr(6.2831853*z) - pixel,
  352.     |z| <= 4
  353.   }
  354.  
  355. PsudoMandel(XAXIS) {; davisl - try center=0,0/magnification=28
  356.   z = Pixel:
  357.    z = ((z/2.7182818)^z)*sqr(6.2831853*z) + pixel,
  358.     |z| <= 4
  359.   }
  360.  
  361. { These are the original "Richard" types sent by Jm Richard-Collard. Their
  362.   generalizations are tacked on to the end of the "Jm" list below, but
  363.   we felt we should keep these around for historical reasons.}
  364.  
  365. Richard1 (XYAXIS) {; Jm Richard-Collard
  366.   z = pixel:
  367.    sq=z*z, z=(sq*sin(sq)+sq)+pixel,
  368.     |z|<=50
  369.   }
  370.  
  371. Richard2 (XYAXIS) {; Jm Richard-Collard
  372.   z = pixel:
  373.    z=1/(sin(z*z+pixel*pixel)),
  374.     |z|<=50
  375.   }
  376.  
  377. Richard3 (XAXIS) {; Jm Richard-Collard
  378.   z = pixel:
  379.    sh=sinh(z), z=(1/(sh*sh))+pixel,
  380.     |z|<=50
  381.   }
  382.  
  383. Richard4 (XAXIS) {; Jm Richard-Collard
  384.   z = pixel:
  385.    z2=z*z, z=(1/(z2*cos(z2)+z2))+pixel,
  386.     |z|<=50
  387.   }
  388.  
  389. Richard5 (XAXIS) {; Jm Richard-Collard
  390.   z = pixel:
  391.    z=sin(z*sinh(z))+pixel,
  392.     |z|<=50
  393.   }
  394.  
  395. Richard6 (XYAXIS) {; Jm Richard-Collard
  396.   z = pixel:
  397.    z=sin(sinh(z))+pixel,
  398.     |z|<=50
  399.   }
  400.  
  401. Richard7 (XAXIS) {; Jm Richard-Collard
  402.   z=pixel:
  403.    z=log(z)*pixel,
  404.     |z|<=50
  405.   }
  406.  
  407. Richard8 (XYAXIS) {; Jm Richard-Collard
  408.   ; This was used for the "Fractal Creations" cover
  409.   z=pixel,sinp = sin(pixel):
  410.    z=sin(z)+sinp,
  411.     |z|<=50
  412.   }
  413.  
  414. Richard9 (XAXIS) {; Jm Richard-Collard
  415.   z=pixel:
  416.    sqrz=z*z, z=sqrz + 1/sqrz + pixel,
  417.     |z|<=4
  418.   }
  419.  
  420. Richard10(XYAXIS) {; Jm Richard-Collard
  421.   z=pixel:
  422.    z=1/sin(1/(z*z)),
  423.     |z|<=50
  424.   }
  425.  
  426. Richard11(XYAXIS) {; Jm Richard-Collard
  427.   z=pixel:
  428.    z=1/sinh(1/(z*z)),
  429.     |z|<=50
  430.   }
  431.  
  432. { These types are generalizations of types sent to us by the French
  433.   mathematician Jm Richard-Collard. If we hadn't generalized them
  434.   there would be --ahhh-- quite a few. With 11 possible values for
  435.   each fn variable,Jm_03, for example, has 14641 variations! }
  436.  
  437. Jm_01 {; generalized Jm Richard-Collard type
  438.   z=pixel,t=p1+4:
  439.    z=(fn1(fn2(z^pixel)))*pixel,
  440.     |z|<=t
  441.   }
  442.  
  443. Jm_02 {; generalized Jm Richard-Collard type
  444.   z=pixel,t=p1+4:
  445.    z=(z^pixel)*fn1(z^pixel),
  446.     |z|<=t
  447.   }
  448.  
  449. Jm_03 {; generalized Jm Richard-Collard type
  450.   z=pixel,t=p1+4:
  451.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel))*pixel,
  452.     |z|<=t
  453.   }
  454.  
  455. Jm_03a {; generalized Jm Richard-Collard type
  456.   z=pixel,t=p1+4:
  457.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel))+pixel,
  458.     |z|<=t
  459.   }
  460.  
  461. Jm_04 {; generalized Jm Richard-Collard type
  462.   z=pixel,t=p1+4:
  463.    z=fn1((fn2(z)*pixel)*fn3(fn4(z)*pixel)),
  464.     |z|<=t
  465.   }
  466.  
  467. Jm_05 {; generalized Jm Richard-Collard type
  468.   z=pixel,t=p1+4:
  469.    z=fn1(fn2((z^pixel))),
  470.     |z|<=t
  471.   }
  472.  
  473. Jm_06 {; generalized Jm Richard-Collard type
  474.   z=pixel,t=p1+4:
  475.    z=fn1(fn2(fn3((z^z)*pixel))),
  476.     |z|<=t
  477.   }
  478.  
  479. Jm_07 {; generalized Jm Richard-Collard type
  480.   z=pixel,t=p1+4:
  481.    z=fn1(fn2(fn3((z^z)*pixel)))*pixel,
  482.     |z|<=t
  483.   }
  484.  
  485. Jm_08 {; generalized Jm Richard-Collard type
  486.   z=pixel,t=p1+4:
  487.    z=fn1(fn2(fn3((z^z)*pixel)))+pixel,
  488.     |z|<=t
  489.   }
  490.  
  491. Jm_09 {; generalized Jm Richard-Collard type
  492.   z=pixel,t=p1+4:
  493.    z=fn1(fn2(fn3(fn4(z))))+pixel,
  494.     |z|<=t
  495.   }
  496.  
  497. Jm_10 {; generalized Jm Richard-Collard type
  498.   z=pixel,t=p1+4:
  499.    z=fn1(fn2(fn3(fn4(z)*pixel))),
  500.     |z|<=t
  501.   }
  502.  
  503. Jm_11 {; generalized Jm Richard-Collard type
  504.   z=pixel,t=p1+4:
  505.    z=fn1(fn2(fn3(fn4(z)*pixel)))*pixel,
  506.     |z|<=t
  507.   }
  508.  
  509. Jm_11a {; generalized Jm Richard-Collard type
  510.   z=pixel,t=p1+4:
  511.    z=fn1(fn2(fn3(fn4(z)*pixel)))+pixel,
  512.     |z|<=t
  513.   }
  514.  
  515. Jm_12 {; generalized Jm Richard-Collard type
  516.   z=pixel,t=p1+4:
  517.    z=fn1(fn2(fn3(z)*pixel)),
  518.     |z|<=t
  519.   }
  520.  
  521. Jm_13 {; generalized Jm Richard-Collard type
  522.   z=pixel,t=p1+4:
  523.    z=fn1(fn2(fn3(z)*pixel))*pixel,
  524.     |z|<=t
  525.   }
  526.  
  527. Jm_14 {; generalized Jm Richard-Collard type
  528.   z=pixel,t=p1+4:
  529.    z=fn1(fn2(fn3(z)*pixel))+pixel,
  530.     |z|<=t
  531.   }
  532.  
  533. Jm_15 {; generalized Jm Richard-Collard type
  534.   z=pixel,t=p1+4:
  535.    f2=fn2(z),z=fn1(f2)*fn3(fn4(f2))*pixel,
  536.     |z|<=t
  537.   }
  538.  
  539. Jm_16 {; generalized Jm Richard-Collard type
  540.   z=pixel,t=p1+4:
  541.    f2=fn2(z),z=fn1(f2)*fn3(fn4(f2))+pixel,
  542.     |z|<=t
  543.   }
  544.  
  545. Jm_17 {; generalized Jm Richard-Collard type
  546.   z=pixel,t=p1+4:
  547.    z=fn1(z)*pixel*fn2(fn3(z)),
  548.     |z|<=t
  549.   }
  550.  
  551. Jm_18 {; generalized Jm Richard-Collard type
  552.   z=pixel,t=p1+4:
  553.    z=fn1(z)*pixel*fn2(fn3(z)*pixel),
  554.     |z|<=t
  555.   }
  556.  
  557. Jm_19 {; generalized Jm Richard-Collard type
  558.   z=pixel,t=p1+4:
  559.    z=fn1(z)*pixel*fn2(fn3(z)+pixel),
  560.     |z|<=t
  561.   }
  562.  
  563. Jm_20 {; generalized Jm Richard-Collard type
  564.   z=pixel,t=p1+4:
  565.    z=fn1(z^pixel),
  566.     |z|<=t
  567.   }
  568.  
  569. Jm_21 {; generalized Jm Richard-Collard type
  570.   z=pixel,t=p1+4:
  571.    z=fn1(z^pixel)*pixel,
  572.     |z|<=t
  573.   }
  574.  
  575. Jm_22 {; generalized Jm Richard-Collard type
  576.   z=pixel,t=p1+4:
  577.    sq=fn1(z), z=(sq*fn2(sq)+sq)+pixel,
  578.     |z|<=t
  579.   }
  580.  
  581. Jm_23 {; generalized Jm Richard-Collard type
  582.   z=pixel,t=p1+4:
  583.    z=fn1(fn2(fn3(z)+pixel*pixel)),
  584.     |z|<=t
  585.   }
  586.  
  587. Jm_24 {; generalized Jm Richard-Collard type
  588.   z=pixel,t=p1+4:
  589.    z2=fn1(z), z=(fn2(z2*fn3(z2)+z2))+pixel,
  590.     |z|<=t
  591.   }
  592.  
  593. Jm_25 {; generalized Jm Richard-Collard type
  594.   z=pixel,t=p1+4:
  595.    z=fn1(z*fn2(z)) + pixel,
  596.     |z|<=t
  597.   }
  598.  
  599. Jm_26 {; generalized Jm Richard-Collard type
  600.   z=pixel,t=p1+4:
  601.    z=fn1(fn2(z)) + pixel,
  602.     |z|<=t
  603.   }
  604.  
  605. Jm_27 {; generalized Jm Richard-Collard type
  606.   z=pixel,t=p1+4:
  607.    sqrz=fn1(z), z=sqrz + 1/sqrz + pixel,
  608.     |z|<=t
  609.   }
  610.  
  611. Jm_ducks(XAXIS) {; Jm Richard-Collard
  612.   ; Not so ugly at first glance and lot of corners to zoom in.
  613.   ; try this: corners=-1.178372/-0.978384/-0.751678/-0.601683
  614.   z=pixel,tst=p1+4,t=1+pixel:
  615.    z=sqr(z)+t,
  616.     |z|<=tst
  617.   }
  618.  
  619. Gamma(XAXIS)={ ; first order gamma function from Prof. Jm
  620.   ; "It's pretty long to generate even on a 486-33 comp but there's a lot
  621.   ; of corners to zoom in and zoom and zoom...beautiful pictures :)"
  622.   z=pixel,twopi=6.283185307179586,r=10:
  623.    z=(twopi*z)^(0.5)*(z^z)*exp(-z)+pixel
  624.     |z|<=r
  625.   }
  626.  
  627. ZZ(XAXIS) { ; Prof Jm using Newton-Raphson method
  628.   ; use floating point with this one
  629.   z=pixel,solution=1:
  630.    z1=z^z;
  631.    z2=(log(z)+1)*z1;
  632.    z=z-(z1-1)/z2 ,
  633.     0.001 <= |solution-z1|
  634.   }
  635.  
  636. ZZa(XAXIS) { ; Prof Jm using Newton-Raphson method
  637.   ; use floating point with this one
  638.   z=pixel,solution=1:
  639.    z1=z^(z-1);
  640.    z2=(((z-1)/z)+log(z))*z1;
  641.    z=z-((z1-1)/z2) ,
  642.     .001 <= |solution-z1|
  643.   }
  644.  
  645.  
  646. comment {
  647.   You should note that for the Transparent 3D fractals the x, y, z, and t
  648.   coordinates correspond to the 2D slices and not the final 3D True Color
  649.   image.  To relate the 2D slices to the 3D image, swap the x- and z-axis,
  650.   i.e. a 90 degree rotation about the y-axis.
  651.                 -Mark Peterson 6-2-91
  652.   }
  653.  
  654. MandelXAxis(XAXIS) {    ; for Transparent3D
  655.   z = zt,        ; Define Julia axes as depth/time and the
  656.   c = xy:        ;   Mandelbrot axes as width/height for each slice.
  657.             ;   This corresponds to Mandelbrot axes as
  658.             ;   height/depth and the Julia axes as width
  659.             ;   time for the 3D image.
  660.    z = Sqr(z) + c
  661.     LastSqr <= 4;
  662.   }
  663.  
  664. OldJulibrot(ORIGIN) {            ; for Transparent3D
  665.   z = real(zt) + flip(imag(xy)),    ; These settings coorespond to the
  666.   c = imag(zt) + flip(real(xy)):    ;    Julia axes as height/width and
  667.                     ;    the Mandelbrot axes as time/depth
  668.                     ;    for the 3D image.
  669.    z = Sqr(z) + c
  670.     LastSqr <= 4;
  671.   }
  672.  
  673.